Move platform abstraction to base library

src/spaces.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_SPACES_H_
 #define V8_SPACES_H_
 
 #include "src/allocation.h"
 #include "src/base/atomicops.h"
+#include "src/base/platform/mutex.h"
 #include "src/hashmap.h"
 #include "src/list.h"
 #include "src/log.h"
-#include "src/platform/mutex.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 class Isolate;
 
 // -----------------------------------------------------------------------------
 // Heap structures:
 //
@@ skipping 297 matching lines @@
     }
   }
 
   void set_owner(Space* space) {
     ASSERT((reinterpret_cast<intptr_t>(space) & kFailureTagMask) == 0);
     owner_ = reinterpret_cast<Address>(space) + kFailureTag;
     ASSERT((reinterpret_cast<intptr_t>(owner_) & kFailureTagMask) ==
            kFailureTag);
   }
 
-  VirtualMemory* reserved_memory() {
+  base::VirtualMemory* reserved_memory() {
     return &reservation_;
   }
 
   void InitializeReservedMemory() {
     reservation_.Reset();
   }
 
-  void set_reserved_memory(VirtualMemory* reservation) {
+  void set_reserved_memory(base::VirtualMemory* reservation) {
     ASSERT_NOT_NULL(reservation);
     reservation_.TakeControl(reservation);
   }
 
   bool scan_on_scavenge() { return IsFlagSet(SCAN_ON_SCAVENGE); }
   void initialize_scan_on_scavenge(bool scan) {
     if (scan) {
       SetFlag(SCAN_ON_SCAVENGE);
     } else {
       ClearFlag(SCAN_ON_SCAVENGE);
@@ skipping 333 matching lines @@
 
  protected:
   size_t size_;
   intptr_t flags_;
 
   // Start and end of allocatable memory on this chunk.
   Address area_start_;
   Address area_end_;
 
   // If the chunk needs to remember its memory reservation, it is stored here.
-  VirtualMemory reservation_;
+  base::VirtualMemory reservation_;
   // The identity of the owning space.  This is tagged as a failure pointer, but
   // no failure can be in an object, so this can be distinguished from any entry
   // in a fixed array.
   Address owner_;
   Heap* heap_;
   // Used by the store buffer to keep track of which pages to mark scan-on-
   // scavenge.
   int store_buffer_counter_;
   // Count of bytes marked black on page.
   int live_byte_count_;
@@ skipping 247 matching lines @@
                                             const size_t commit_size,
                                             size_t* allocated);
   bool CommitRawMemory(Address start, size_t length);
   bool UncommitRawMemory(Address start, size_t length);
   void FreeRawMemory(Address buf, size_t length);
 
  private:
   Isolate* isolate_;
 
   // The reserved range of virtual memory that all code objects are put in.
-  VirtualMemory* code_range_;
+  base::VirtualMemory* code_range_;
   // Plain old data class, just a struct plus a constructor.
   class FreeBlock {
    public:
     FreeBlock(Address start_arg, size_t size_arg)
         : start(start_arg), size(size_arg) {
       ASSERT(IsAddressAligned(start, MemoryChunk::kAlignment));
       ASSERT(size >= static_cast<size_t>(Page::kPageSize));
     }
     FreeBlock(void* start_arg, size_t size_arg)
         : start(static_cast<Address>(start_arg)), size(size_arg) {
@@ skipping 137 matching lines @@
   // 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,
                              Space* space);
 
   Address ReserveAlignedMemory(size_t requested,
                                size_t alignment,
-                               VirtualMemory* controller);
+                               base::VirtualMemory* controller);
   Address AllocateAlignedMemory(size_t reserve_size,
                                 size_t commit_size,
                                 size_t alignment,
                                 Executability executable,
-                                VirtualMemory* controller);
+                                base::VirtualMemory* controller);
 
   bool CommitMemory(Address addr, size_t size, Executability executable);
 
-  void FreeMemory(VirtualMemory* reservation, Executability executable);
+  void FreeMemory(base::VirtualMemory* reservation, Executability executable);
   void FreeMemory(Address addr, size_t size, Executability executable);
 
   // 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);
 
   // Uncommit a contiguous block of memory [start..(start+size)[.
   // start is not NULL, the size is greater than zero, and the
@@ skipping 24 matching lines @@
   static int CodePageGuardSize();
 
   static int CodePageAreaStartOffset();
 
   static int CodePageAreaEndOffset();
 
   static int CodePageAreaSize() {
     return CodePageAreaEndOffset() - CodePageAreaStartOffset();
   }
 
-  MUST_USE_RESULT bool CommitExecutableMemory(VirtualMemory* vm,
+  MUST_USE_RESULT bool CommitExecutableMemory(base::VirtualMemory* vm,
                                               Address start,
                                               size_t commit_size,
                                               size_t reserved_size);
 
  private:
   Isolate* isolate_;
 
   // Maximum space size in bytes.
   size_t capacity_;
   // Maximum subset of capacity_ that can be executable
@@ skipping 360 matching lines @@
   }
 
   FreeListNode** GetEndAddress() { return &end_; }
   FreeListNode* end() const { return end_; }
   void set_end(FreeListNode* end) { end_ = end; }
 
   int* GetAvailableAddress() { return &available_; }
   int available() const { return available_; }
   void set_available(int available) { available_ = available; }
 
-  Mutex* mutex() { return &mutex_; }
+  base::Mutex* mutex() { return &mutex_; }
 
   bool IsEmpty() {
     return top() == 0;
   }
 
 #ifdef DEBUG
   intptr_t SumFreeList();
   int FreeListLength();
 #endif
 
  private:
   // top_ points to the top FreeListNode* in the free list category.
   base::AtomicWord top_;
   FreeListNode* end_;
-  Mutex mutex_;
+  base::Mutex mutex_;
 
   // Total available bytes in all blocks of this free list category.
   int available_;
 };
 
 
 // The free list for the old space.  The free list is organized in such a way
 // as to encourage objects allocated around the same time to be near each
 // other.  The normal way to allocate is intended to be by bumping a 'top'
 // pointer until it hits a 'limit' pointer.  When the limit is hit we need to
@@ skipping 1070 matching lines @@
  private:
   // Update allocation info to match the current to-space page.
   void UpdateAllocationInfo();
 
   Address chunk_base_;
   uintptr_t chunk_size_;
 
   // The semispaces.
   SemiSpace to_space_;
   SemiSpace from_space_;
-  VirtualMemory reservation_;
+  base::VirtualMemory reservation_;
   int pages_used_;
 
   // Start address and bit mask for containment testing.
   Address start_;
   uintptr_t address_mask_;
   uintptr_t object_mask_;
   uintptr_t object_expected_;
 
   // Allocation pointer and limit for normal allocation and allocation during
   // mark-compact collection.
@@ skipping 333 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_