Refactor and cleanup VirtualMemory.

src/spaces.h

 // 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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_SPACES_H_
 #define V8_SPACES_H_
 
 #include "allocation.h"
 #include "hashmap.h"
 #include "list.h"
 #include "log.h"
 #include "platform/mutex.h"
+#include "platform/virtual-memory.h"
 #include "v8utils.h"
 
 namespace v8 {
 namespace internal {
 
 class Isolate;
 
 // -----------------------------------------------------------------------------
 // Heap structures:
 //
@@ skipping 520 matching lines @@
 
   void set_size(size_t size) {
     size_ = size;
   }
 
   void SetArea(Address area_start, Address area_end) {
     area_start_ = area_start;
     area_end_ = area_end;
   }
 
-  Executability executable() {
-    return IsFlagSet(IS_EXECUTABLE) ? EXECUTABLE : NOT_EXECUTABLE;
+  VirtualMemory::Executability executability() {
+    return IsFlagSet(IS_EXECUTABLE)
+        ? VirtualMemory::EXECUTABLE
+        : VirtualMemory::NOT_EXECUTABLE;
   }
 
   bool ContainsOnlyData() {
     return IsFlagSet(CONTAINS_ONLY_DATA);
   }
 
   bool InNewSpace() {
     return (flags_ & ((1 << IN_FROM_SPACE) | (1 << IN_TO_SPACE))) != 0;
   }
 
@@ skipping 121 matching lines @@
   intptr_t available_in_medium_free_list_;
   intptr_t available_in_large_free_list_;
   intptr_t available_in_huge_free_list_;
   intptr_t non_available_small_blocks_;
 
   static MemoryChunk* Initialize(Heap* heap,
                                  Address base,
                                  size_t size,
                                  Address area_start,
                                  Address area_end,
-                                 Executability executable,
+                                 VirtualMemory::Executability executability,
                                  Space* owner);
 
   friend class MemoryAllocator;
 };
 
 
 STATIC_CHECK(sizeof(MemoryChunk) <= MemoryChunk::kHeaderSize);
 
 
 // -----------------------------------------------------------------------------
@@ skipping 59 matching lines @@
   static const int kMaxNonCodeHeapObjectSize =
       kNonCodeObjectAreaSize - kPointerSize;
 
   // Page size mask.
   static const intptr_t kPageAlignmentMask = (1 << kPageSizeBits) - 1;
 
   inline void ClearGCFields();
 
   static inline Page* Initialize(Heap* heap,
                                  MemoryChunk* chunk,
-                                 Executability executable,
+                                 VirtualMemory::Executability executable,
                                  PagedSpace* owner);
 
   void InitializeAsAnchor(PagedSpace* owner);
 
   bool WasSweptPrecisely() { return IsFlagSet(WAS_SWEPT_PRECISELY); }
   bool WasSweptConservatively() { return IsFlagSet(WAS_SWEPT_CONSERVATIVELY); }
   bool WasSwept() { return WasSweptPrecisely() || WasSweptConservatively(); }
 
   void MarkSweptPrecisely() { SetFlag(WAS_SWEPT_PRECISELY); }
   void MarkSweptConservatively() { SetFlag(WAS_SWEPT_CONSERVATIVELY); }
@@ skipping 45 matching lines @@
 
   friend class MemoryAllocator;
 };
 
 STATIC_CHECK(sizeof(LargePage) <= MemoryChunk::kHeaderSize);
 
 // ----------------------------------------------------------------------------
 // Space is the abstract superclass for all allocation spaces.
 class Space : public Malloced {
  public:
-  Space(Heap* heap, AllocationSpace id, Executability executable)
-      : heap_(heap), id_(id), executable_(executable) {}
+  Space(Heap* heap,
+        AllocationSpace id,
+        VirtualMemory::Executability executability)
+      : heap_(heap), id_(id), executability_(executability) {}
 
   virtual ~Space() {}
 
   Heap* heap() const { return heap_; }
 
   // Does the space need executable memory?
-  Executability executable() { return executable_; }
+  VirtualMemory::Executability executability() { return executability_; }
 
   // Identity used in error reporting.
   AllocationSpace identity() { return id_; }
 
   // Returns allocated size.
   virtual intptr_t Size() = 0;
 
   // Returns size of objects. Can differ from the allocated size
   // (e.g. see LargeObjectSpace).
   virtual intptr_t SizeOfObjects() { return Size(); }
 
   virtual int RoundSizeDownToObjectAlignment(int size) {
     if (id_ == CODE_SPACE) {
       return RoundDown(size, kCodeAlignment);
     } else {
       return RoundDown(size, kPointerSize);
     }
   }
 
 #ifdef DEBUG
   virtual void Print() = 0;
 #endif
 
  private:
   Heap* heap_;
   AllocationSpace id_;
-  Executability executable_;
+  VirtualMemory::Executability executability_;
 };
 
 
 // ----------------------------------------------------------------------------
 // All heap objects containing executable code (code objects) must be allocated
 // from a 2 GB range of memory, so that they can call each other using 32-bit
 // displacements.  This happens automatically on 32-bit platforms, where 32-bit
 // displacements cover the entire 4GB virtual address space.  On 64-bit
 // platforms, we support this using the CodeRange object, which reserves and
 // manages a range of virtual memory.
@@ skipping 137 matching lines @@
 class MemoryAllocator {
  public:
   explicit MemoryAllocator(Isolate* isolate);
 
   // Initializes its internal bookkeeping structures.
   // Max capacity of the total space and executable memory limit.
   bool SetUp(intptr_t max_capacity, intptr_t capacity_executable);
 
   void TearDown();
 
-  Page* AllocatePage(
-      intptr_t size, PagedSpace* owner, Executability executable);
+  Page* AllocatePage(intptr_t size,
+                     PagedSpace* owner,
+                     VirtualMemory::Executability executability);
 
-  LargePage* AllocateLargePage(
-      intptr_t object_size, Space* owner, Executability executable);
+  LargePage* AllocateLargePage(intptr_t object_size,
+                               Space* owner,
+                               VirtualMemory::Executability executability);
 
   void Free(MemoryChunk* chunk);
 
   // Returns the maximum available bytes of heaps.
   intptr_t Available() { return capacity_ < size_ ? 0 : capacity_ - size_; }
 
   // Returns allocated spaces in bytes.
   intptr_t Size() { return size_; }
 
   // Returns the maximum available executable bytes of heaps.
@@ skipping 20 matching lines @@
 #ifdef DEBUG
   // Reports statistic info of the space.
   void ReportStatistics();
 #endif
 
   // Returns a MemoryChunk in which the memory region from commit_area_size to
   // reserve_area_size of the chunk area is reserved but not committed, it
   // could be committed later by calling MemoryChunk::CommitArea.
   MemoryChunk* AllocateChunk(intptr_t reserve_area_size,
                              intptr_t commit_area_size,
-                             Executability executable,
+                             VirtualMemory::Executability executability,
                              Space* space);
 
   Address ReserveAlignedMemory(size_t requested,
                                size_t alignment,
                                VirtualMemory* controller);
   Address AllocateAlignedMemory(size_t reserve_size,
                                 size_t commit_size,
                                 size_t alignment,
-                                Executability executable,
+                                VirtualMemory::Executability executability,
                                 VirtualMemory* controller);
 
-  bool CommitMemory(Address addr, size_t size, Executability executable);
+  bool CommitMemory(Address addr,
+                    size_t size,
+                    VirtualMemory::Executability executability);
 
-  void FreeMemory(VirtualMemory* reservation, Executability executable);
-  void FreeMemory(Address addr, size_t size, Executability executable);
+  void FreeMemory(VirtualMemory* reservation,
+                  VirtualMemory::Executability executability);
+  void FreeMemory(Address addr,
+                  size_t size,
+                  VirtualMemory::Executability executability);
 
   // Commit a contiguous block of memory from the initial chunk.  Assumes that
   // the address is not NULL, the size is greater than zero, and that the
   // block is contained in the initial chunk.  Returns true if it succeeded
   // and false otherwise.
-  bool CommitBlock(Address start, size_t size, Executability executable);
+  bool CommitBlock(Address start,
+                   size_t size,
+                   VirtualMemory::Executability executability);
 
   // Uncommit a contiguous block of memory [start..(start+size)[.
   // start is not NULL, the size is greater than zero, and the
   // block is contained in the initial chunk.  Returns true if it succeeded
   // and false otherwise.
   bool UncommitBlock(Address start, size_t size);
 
   // Zaps a contiguous block of memory [start..(start+size)[ thus
   // filling it up with a recognizable non-NULL bit pattern.
   void ZapBlock(Address start, size_t size);
@@ skipping 470 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(FreeList);
 };
 
 
 class PagedSpace : public Space {
  public:
   // Creates a space with a maximum capacity, and an id.
   PagedSpace(Heap* heap,
              intptr_t max_capacity,
              AllocationSpace id,
-             Executability executable);
+             VirtualMemory::Executability executability);
 
   virtual ~PagedSpace() {}
 
   // Set up the space using the given address range of virtual memory (from
   // the memory allocator's initial chunk) if possible.  If the block of
   // addresses is not big enough to contain a single page-aligned page, a
   // fresh chunk will be allocated.
   bool SetUp();
 
   // Returns true if the space has been successfully set up and not
@@ skipping 404 matching lines @@
 // SemiSpace in young generation
 //
 // A semispace is a contiguous chunk of memory holding page-like memory
 // chunks. The mark-compact collector  uses the memory of the first page in
 // the from space as a marking stack when tracing live objects.
 
 class SemiSpace : public Space {
  public:
   // Constructor.
   SemiSpace(Heap* heap, SemiSpaceId semispace)
-    : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
+    : Space(heap, NEW_SPACE, VirtualMemory::NOT_EXECUTABLE),
       start_(NULL),
       age_mark_(NULL),
       id_(semispace),
       anchor_(this),
       current_page_(NULL) { }
 
   // Sets up the semispace using the given chunk.
   void SetUp(Address start, int initial_capacity, int maximum_capacity);
 
   // Tear down the space.  Heap memory was not allocated by the space, so it
@@ skipping 232 matching lines @@
 // -----------------------------------------------------------------------------
 // The young generation space.
 //
 // The new space consists of a contiguous pair of semispaces.  It simply
 // forwards most functions to the appropriate semispace.
 
 class NewSpace : public Space {
  public:
   // Constructor.
   explicit NewSpace(Heap* heap)
-    : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
+    : Space(heap, NEW_SPACE, VirtualMemory::NOT_EXECUTABLE),
       to_space_(heap, kToSpace),
       from_space_(heap, kFromSpace),
       reservation_(),
       inline_allocation_limit_step_(0) {}
 
   // Sets up the new space using the given chunk.
   bool SetUp(int reserved_semispace_size_, int max_semispace_size);
 
   // Tears down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
@@ skipping 244 matching lines @@
 // -----------------------------------------------------------------------------
 // Old object space (excluding map objects)
 
 class OldSpace : public PagedSpace {
  public:
   // Creates an old space object with a given maximum capacity.
   // The constructor does not allocate pages from OS.
   OldSpace(Heap* heap,
            intptr_t max_capacity,
            AllocationSpace id,
-           Executability executable)
-      : PagedSpace(heap, max_capacity, id, executable) {
+           VirtualMemory::Executability executability)
+      : PagedSpace(heap, max_capacity, id, executability) {
     page_extra_ = 0;
   }
 
   // The limit of allocation for a page in this space.
   virtual Address PageAllocationLimit(Page* page) {
     return page->area_end();
   }
 
  public:
   TRACK_MEMORY("OldSpace")
@@ skipping 10 matching lines @@
 
 // -----------------------------------------------------------------------------
 // Old space for objects of a fixed size
 
 class FixedSpace : public PagedSpace {
  public:
   FixedSpace(Heap* heap,
              intptr_t max_capacity,
              AllocationSpace id,
              int object_size_in_bytes)
-      : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE),
+      : PagedSpace(heap, max_capacity, id, VirtualMemory::NOT_EXECUTABLE),
         object_size_in_bytes_(object_size_in_bytes) {
     page_extra_ = Page::kNonCodeObjectAreaSize % object_size_in_bytes;
   }
 
   // The limit of allocation for a page in this space.
   virtual Address PageAllocationLimit(Page* page) {
     return page->area_end() - page_extra_;
   }
 
   int object_size_in_bytes() { return object_size_in_bytes_; }
@@ skipping 119 matching lines @@
   // Releases internal resources, frees objects in this space.
   void TearDown();
 
   static intptr_t ObjectSizeFor(intptr_t chunk_size) {
     if (chunk_size <= (Page::kPageSize + Page::kObjectStartOffset)) return 0;
     return chunk_size - Page::kPageSize - Page::kObjectStartOffset;
   }
 
   // Shared implementation of AllocateRaw, AllocateRawCode and
   // AllocateRawFixedArray.
-  MUST_USE_RESULT MaybeObject* AllocateRaw(int object_size,
-                                           Executability executable);
+  MUST_USE_RESULT MaybeObject* AllocateRaw(
+      int object_size, VirtualMemory::Executability executability);
 
   // Available bytes for objects in this space.
   inline intptr_t Available();
 
   virtual intptr_t Size() {
     return size_;
   }
 
   virtual intptr_t SizeOfObjects() {
     return objects_size_;
@@ skipping 154 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_