Version 2.3.10...

src/spaces.h

 // Copyright 2006-2008 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 179 matching lines @@
   // only after PagedSpace::PrepareForMarkCompact was called.
   inline bool WasInUseBeforeMC();
 
   inline void SetWasInUseBeforeMC(bool was_in_use);
 
   // True if this page is a large object page.
   inline bool IsLargeObjectPage();
 
   inline void SetIsLargeObjectPage(bool is_large_object_page);
 
+  inline bool IsPageExecutable();
+
+  inline void SetIsPageExecutable(bool is_page_executable);
+
   // Returns the offset of a given address to this page.
   INLINE(int Offset(Address a)) {
     int offset = static_cast<int>(a - address());
     ASSERT_PAGE_OFFSET(offset);
     return offset;
   }
 
   // Returns the address for a given offset to the this page.
   Address OffsetToAddress(int offset) {
     ASSERT_PAGE_OFFSET(offset);
@@ skipping 39 matching lines @@
   static const int kMaxHeapObjectSize = kObjectAreaSize;
 
   static const int kDirtyFlagOffset = 2 * kPointerSize;
   static const int kRegionSizeLog2 = 8;
   static const int kRegionSize = 1 << kRegionSizeLog2;
   static const intptr_t kRegionAlignmentMask = (kRegionSize - 1);
 
   STATIC_CHECK(kRegionSize == kPageSize / kBitsPerInt);
 
   enum PageFlag {
-    IS_NORMAL_PAGE = 1 << 0,
-    WAS_IN_USE_BEFORE_MC = 1 << 1,
+    IS_NORMAL_PAGE = 0,
+    WAS_IN_USE_BEFORE_MC,
 
     // Page allocation watermark was bumped by preallocation during scavenge.
     // Correct watermark can be retrieved by CachedAllocationWatermark() method
-    WATERMARK_INVALIDATED = 1 << 2
+    WATERMARK_INVALIDATED,
+    IS_EXECUTABLE,
+    NUM_PAGE_FLAGS  // Must be last
   };
+  static const int kPageFlagMask = (1 << NUM_PAGE_FLAGS) - 1;
 
   // To avoid an additional WATERMARK_INVALIDATED flag clearing pass during
   // scavenge we just invalidate the watermark on each old space page after
   // processing it. And then we flip the meaning of the WATERMARK_INVALIDATED
   // flag at the beginning of the next scavenge and each page becomes marked as
   // having a valid watermark.
   //
   // The following invariant must hold for pages in old pointer and map spaces:
   //     If page is in use then page is marked as having invalid watermark at
   //     the beginning and at the end of any GC.
   //
   // This invariant guarantees that after flipping flag meaning at the
   // beginning of scavenge all pages in use will be marked as having valid
   // watermark.
   static inline void FlipMeaningOfInvalidatedWatermarkFlag();
 
   // Returns true if the page allocation watermark was not altered during
   // scavenge.
   inline bool IsWatermarkValid();
 
   inline void InvalidateWatermark(bool value);
 
   inline bool GetPageFlag(PageFlag flag);
   inline void SetPageFlag(PageFlag flag, bool value);
   inline void ClearPageFlags();
 
   inline void ClearGCFields();
 
-  static const int kAllocationWatermarkOffsetShift = 3;
+  static const int kAllocationWatermarkOffsetShift = WATERMARK_INVALIDATED + 1;
   static const int kAllocationWatermarkOffsetBits  = kPageSizeBits + 1;
   static const uint32_t kAllocationWatermarkOffsetMask =
       ((1 << kAllocationWatermarkOffsetBits) - 1) <<
       kAllocationWatermarkOffsetShift;
 
   static const uint32_t kFlagsMask =
     ((1 << kAllocationWatermarkOffsetShift) - 1);
 
   STATIC_CHECK(kBitsPerInt - kAllocationWatermarkOffsetShift >=
                kAllocationWatermarkOffsetBits);
@@ skipping 245 matching lines @@
 
   // Allocates and frees raw memory of certain size.
   // These are just thin wrappers around OS::Allocate and OS::Free,
   // but keep track of allocated bytes as part of heap.
   // If the flag is EXECUTABLE and a code range exists, the requested
   // memory is allocated from the code range.  If a code range exists
   // and the freed memory is in it, the code range manages the freed memory.
   static void* AllocateRawMemory(const size_t requested,
                                  size_t* allocated,
                                  Executability executable);
-  static void FreeRawMemory(void* buf, size_t length);
+  static void FreeRawMemory(void* buf,
+                            size_t length,
+                            Executability executable);
 
   // Returns the maximum available bytes of heaps.
   static int Available() { return capacity_ < size_ ? 0 : capacity_ - size_; }
 
   // Returns allocated spaces in bytes.
   static int Size() { return size_; }
 
+  // Returns allocated executable spaces in bytes.
+  static int SizeExecutable() { return size_executable_; }
+
   // Returns maximum available bytes that the old space can have.
   static int MaxAvailable() {
     return (Available() / Page::kPageSize) * Page::kObjectAreaSize;
   }
 
   // Links two pages.
   static inline void SetNextPage(Page* prev, Page* next);
 
   // Returns the next page of a given page.
   static inline Page* GetNextPage(Page* p);
@@ skipping 43 matching lines @@
   static const int kPagesPerChunk = 16;
 #endif
   static const int kChunkSize = kPagesPerChunk * Page::kPageSize;
 
  private:
   // Maximum space size in bytes.
   static int capacity_;
 
   // Allocated space size in bytes.
   static int size_;
+  // Allocated executable space size in bytes.
+  static int size_executable_;
 
   // The initial chunk of virtual memory.
   static VirtualMemory* initial_chunk_;
 
   // Allocated chunk info: chunk start address, chunk size, and owning space.
   class ChunkInfo BASE_EMBEDDED {
    public:
     ChunkInfo() : address_(NULL), size_(0), owner_(NULL) {}
     void init(Address a, size_t s, PagedSpace* o) {
       address_ = a;
@@ skipping 1410 matching lines @@
     return reinterpret_cast<LargeObjectChunk*>(address);
   }
 
   // Returns the address of this chunk.
   Address address() { return reinterpret_cast<Address>(this); }
 
   // Accessors for the fields of the chunk.
   LargeObjectChunk* next() { return next_; }
   void set_next(LargeObjectChunk* chunk) { next_ = chunk; }
 
-  size_t size() { return size_; }
+  size_t size() { return size_ & ~Page::kPageFlagMask; }
   void set_size(size_t size_in_bytes) { size_ = size_in_bytes; }
 
   // Returns the object in this chunk.
   inline HeapObject* GetObject();
 
   // Given a requested size returns the physical size of a chunk to be
   // allocated.
   static int ChunkSizeFor(int size_in_bytes);
 
   // Given a chunk size, returns the object size it can accommodate.  Used by
@@ skipping 116 matching lines @@
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_