Merge r10809 into 3.7 branch

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 85 matching lines @@
 #define ASSERT_PAGE_ALIGNED(address)                                           \
   ASSERT((OffsetFrom(address) & Page::kPageAlignmentMask) == 0)
 
 #define ASSERT_OBJECT_ALIGNED(address)                                         \
   ASSERT((OffsetFrom(address) & kObjectAlignmentMask) == 0)
 
 #define ASSERT_MAP_ALIGNED(address)                                            \
   ASSERT((OffsetFrom(address) & kMapAlignmentMask) == 0)
 
 #define ASSERT_OBJECT_SIZE(size)                                               \
-  ASSERT((0 < size) && (size <= Page::kMaxHeapObjectSize))
+  ASSERT((0 < size) && (size <= Page::kMaxNonCodeHeapObjectSize))
 
 #define ASSERT_PAGE_OFFSET(offset)                                             \
   ASSERT((Page::kObjectStartOffset <= offset)                                  \
       && (offset <= Page::kPageSize))
 
 #define ASSERT_MAP_PAGE_INDEX(index)                                           \
   ASSERT((0 <= index) && (index <= MapSpace::kMaxMapPageIndex))
 
 
 class PagedSpace;
@@ skipping 237 matching lines @@
       ClearFlag(SCAN_ON_SCAVENGE);
     }
   }
   inline void set_scan_on_scavenge(bool scan);
 
   int store_buffer_counter() { return store_buffer_counter_; }
   void set_store_buffer_counter(int counter) {
     store_buffer_counter_ = counter;
   }
 
-  Address body() { return address() + kObjectStartOffset; }
-
-  Address body_limit() { return address() + size(); }
-
-  int body_size() { return static_cast<int>(size() - kObjectStartOffset); }
-
   bool Contains(Address addr) {
-    return addr >= body() && addr < address() + size();
+    return addr >= area_start() && addr < area_end();
   }
 
   // Checks whether addr can be a limit of addresses in this page.
   // It's a limit if it's in the page, or if it's just after the
   // last byte of the page.
   bool ContainsLimit(Address addr) {
-    return addr >= body() && addr <= address() + size();
+    return addr >= area_start() && addr <= area_end();
   }
 
   enum MemoryChunkFlags {
     IS_EXECUTABLE,
     ABOUT_TO_BE_FREED,
     POINTERS_TO_HERE_ARE_INTERESTING,
     POINTERS_FROM_HERE_ARE_INTERESTING,
     SCAN_ON_SCAVENGE,
     IN_FROM_SPACE,  // Mutually exclusive with IN_TO_SPACE.
     IN_TO_SPACE,    // All pages in new space has one of these two set.
@@ skipping 88 matching lines @@
   }
 
   static const intptr_t kAlignment =
       (static_cast<uintptr_t>(1) << kPageSizeBits);
 
   static const intptr_t kAlignmentMask = kAlignment - 1;
 
   static const intptr_t kSizeOffset = kPointerSize + kPointerSize;
 
   static const intptr_t kLiveBytesOffset =
-      kSizeOffset + kPointerSize + kPointerSize + kPointerSize +
-      kPointerSize + kPointerSize + kPointerSize + kIntSize;
+     kSizeOffset + kPointerSize + kPointerSize + kPointerSize +
+     kPointerSize + kPointerSize +
+     kPointerSize + kPointerSize + kPointerSize + kIntSize;
 
   static const size_t kSlotsBufferOffset = kLiveBytesOffset + kIntSize;
 
   static const size_t kHeaderSize =
       kSlotsBufferOffset + kPointerSize + kPointerSize;
 
   static const int kBodyOffset =
     CODE_POINTER_ALIGN(MAP_POINTER_ALIGN(kHeaderSize + Bitmap::kSize));
 
   // The start offset of the object area in a page. Aligned to both maps and
@@ skipping 85 matching lines @@
   void MarkEvacuationCandidate() {
     ASSERT(slots_buffer_ == NULL);
     SetFlag(EVACUATION_CANDIDATE);
   }
 
   void ClearEvacuationCandidate() {
     ASSERT(slots_buffer_ == NULL);
     ClearFlag(EVACUATION_CANDIDATE);
   }
 
+  Address area_start() { return area_start_; }
+  Address area_end() { return area_end_; }
+  int area_size() {
+    return static_cast<int>(area_end() - area_start());
+  }
 
  protected:
   MemoryChunk* next_chunk_;
   MemoryChunk* prev_chunk_;
   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_;
   // 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_;
   SlotsBuffer* slots_buffer_;
   SkipList* skip_list_;
 
   static MemoryChunk* Initialize(Heap* heap,
                                  Address base,
                                  size_t size,
+                                 Address area_start,
+                                 Address area_end,
                                  Executability executable,
                                  Space* owner);
 
   friend class MemoryAllocator;
 };
 
 STATIC_CHECK(sizeof(MemoryChunk) <= MemoryChunk::kHeaderSize);
 
 // -----------------------------------------------------------------------------
 // A page is a memory chunk of a size 1MB. Large object pages may be larger.
@@ skipping 19 matching lines @@
     Page* p = FromAddress(top - kPointerSize);
     return p;
   }
 
   // Returns the next page in the chain of pages owned by a space.
   inline Page* next_page();
   inline Page* prev_page();
   inline void set_next_page(Page* page);
   inline void set_prev_page(Page* page);
 
-  // Returns the start address of the object area in this page.
-  Address ObjectAreaStart() { return address() + kObjectStartOffset; }
-
-  // Returns the end address (exclusive) of the object area in this page.
-  Address ObjectAreaEnd() { return address() + Page::kPageSize; }
-
   // Checks whether an address is page aligned.
   static bool IsAlignedToPageSize(Address a) {
     return 0 == (OffsetFrom(a) & kPageAlignmentMask);
   }
 
   // Returns the offset of a given address to this page.
   INLINE(int Offset(Address a)) {
     int offset = static_cast<int>(a - address());
     return offset;
   }
 
   // Returns the address for a given offset to the this page.
   Address OffsetToAddress(int offset) {
     ASSERT_PAGE_OFFSET(offset);
     return address() + offset;
   }
 
   // ---------------------------------------------------------------------
 
   // Page size in bytes.  This must be a multiple of the OS page size.
   static const int kPageSize = 1 << kPageSizeBits;
 
+  // Object area size in bytes.
+  static const int kNonCodeObjectAreaSize = kPageSize - kObjectStartOffset;
+
+  // Maximum object size that fits in a page.
+  static const int kMaxNonCodeHeapObjectSize = kNonCodeObjectAreaSize;
+
   // Page size mask.
   static const intptr_t kPageAlignmentMask = (1 << kPageSizeBits) - 1;
 
-  // Object area size in bytes.
-  static const int kObjectAreaSize = kPageSize - kObjectStartOffset;
-
-  // Maximum object size that fits in a page.
-  static const int kMaxHeapObjectSize = kObjectAreaSize;
-
-  static const int kFirstUsedCell =
-    (kObjectStartOffset/kPointerSize) >> Bitmap::kBitsPerCellLog2;
-
-  static const int kLastUsedCell =
-    ((kPageSize - kPointerSize)/kPointerSize) >>
-      Bitmap::kBitsPerCellLog2;
-
   inline void ClearGCFields();
 
   static inline Page* Initialize(Heap* heap,
                                  MemoryChunk* chunk,
                                  Executability executable,
                                  PagedSpace* owner);
 
   void InitializeAsAnchor(PagedSpace* owner);
 
   bool WasSweptPrecisely() { return IsFlagSet(WAS_SWEPT_PRECISELY); }
@@ skipping 13 matching lines @@
   friend class MemoryAllocator;
 };
 
 
 STATIC_CHECK(sizeof(Page) <= MemoryChunk::kHeaderSize);
 
 
 class LargePage : public MemoryChunk {
  public:
   HeapObject* GetObject() {
-    return HeapObject::FromAddress(body());
+    return HeapObject::FromAddress(area_start());
   }
 
   inline LargePage* next_page() const {
     return static_cast<LargePage*>(next_chunk());
   }
 
   inline void set_next_page(LargePage* page) {
     set_next_chunk(page);
   }
  private:
@@ skipping 220 matching lines @@
   intptr_t AvailableExecutable() {
     if (capacity_executable_ < size_executable_) return 0;
     return capacity_executable_ - size_executable_;
   }
 
   // Returns allocated executable spaces in bytes.
   intptr_t SizeExecutable() { return size_executable_; }
 
   // Returns maximum available bytes that the old space can have.
   intptr_t MaxAvailable() {
-    return (Available() / Page::kPageSize) * Page::kObjectAreaSize;
+    return (Available() / Page::kPageSize) * Page::kMaxNonCodeHeapObjectSize;
   }
 
 #ifdef DEBUG
   // Reports statistic info of the space.
   void ReportStatistics();
 #endif
 
   MemoryChunk* AllocateChunk(intptr_t body_size,
                              Executability executable,
                              Space* space);
@@ skipping 32 matching lines @@
   void AddMemoryAllocationCallback(MemoryAllocationCallback callback,
                                           ObjectSpace space,
                                           AllocationAction action);
 
   void RemoveMemoryAllocationCallback(
       MemoryAllocationCallback callback);
 
   bool MemoryAllocationCallbackRegistered(
       MemoryAllocationCallback callback);
 
+  static int CodePageGuardStartOffset();
+
+  static int CodePageGuardSize();
+
+  static int CodePageAreaStartOffset();
+
+  static int CodePageAreaEndOffset();
+
+  static int CodePageAreaSize() {
+    return CodePageAreaEndOffset() - CodePageAreaStartOffset();
+  }
+
+  static bool CommitCodePage(VirtualMemory* vm, Address start, size_t size);
+
  private:
   Isolate* isolate_;
 
   // Maximum space size in bytes.
   size_t capacity_;
   // Maximum subset of capacity_ that can be executable
   size_t capacity_executable_;
 
   // Allocated space size in bytes.
   size_t size_;
@@ skipping 332 matching lines @@
     intptr_t huge_size_;
   };
 
   void CountFreeListItems(Page* p, SizeStats* sizes);
 
   intptr_t EvictFreeListItems(Page* p);
 
  private:
   // The size range of blocks, in bytes.
   static const int kMinBlockSize = 3 * kPointerSize;
-  static const int kMaxBlockSize = Page::kMaxHeapObjectSize;
+  static const int kMaxBlockSize = Page::kMaxNonCodeHeapObjectSize;
 
   FreeListNode* PickNodeFromList(FreeListNode** list, int* node_size);
 
   FreeListNode* FindNodeFor(int size_in_bytes, int* node_size);
 
   PagedSpace* owner_;
   Heap* heap_;
 
   // Total available bytes in all blocks on this free list.
   int available_;
@@ skipping 183 matching lines @@
   // worth defragmenting them.  Otherwise a positive integer that gives an
   // estimate of fragmentation on an arbitrary scale.
   int Fragmentation(Page* p) {
     FreeList::SizeStats sizes;
     free_list_.CountFreeListItems(p, &sizes);
 
     intptr_t ratio;
     intptr_t ratio_threshold;
     if (identity() == CODE_SPACE) {
       ratio = (sizes.medium_size_ * 10 + sizes.large_size_ * 2) * 100 /
-          Page::kObjectAreaSize;
+          AreaSize();
       ratio_threshold = 10;
     } else {
       ratio = (sizes.small_size_ * 5 + sizes.medium_size_) * 100 /
-          Page::kObjectAreaSize;
+          AreaSize();
       ratio_threshold = 15;
     }
 
     if (FLAG_trace_fragmentation) {
       PrintF("%p [%d]: %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %s\n",
              reinterpret_cast<void*>(p),
              identity(),
              static_cast<int>(sizes.small_size_),
              static_cast<double>(sizes.small_size_ * 100) /
-                 Page::kObjectAreaSize,
+                 AreaSize(),
              static_cast<int>(sizes.medium_size_),
              static_cast<double>(sizes.medium_size_ * 100) /
-                 Page::kObjectAreaSize,
+                 AreaSize(),
              static_cast<int>(sizes.large_size_),
              static_cast<double>(sizes.large_size_ * 100) /
-                 Page::kObjectAreaSize,
+                 AreaSize(),
              static_cast<int>(sizes.huge_size_),
              static_cast<double>(sizes.huge_size_ * 100) /
-                 Page::kObjectAreaSize,
+                 AreaSize(),
              (ratio > ratio_threshold) ? "[fragmented]" : "");
     }
 
-    if (FLAG_always_compact && sizes.Total() != Page::kObjectAreaSize) {
+    if (FLAG_always_compact && sizes.Total() != AreaSize()) {
       return 1;
     }
     if (ratio <= ratio_threshold) return 0;  // Not fragmented.
 
     return static_cast<int>(ratio - ratio_threshold);
   }
 
   void EvictEvacuationCandidatesFromFreeLists();
 
   bool CanExpand();
 
   // Returns the number of total pages in this space.
   int CountTotalPages();
 
+  // Return size of allocatable area on a page in this space.
+  inline int AreaSize() {
+    return area_size_;
+  }
+
  protected:
+  int area_size_;
+
   // Maximum capacity of this space.
   intptr_t max_capacity_;
 
   // Accounting information for this space.
   AllocationStats accounting_stats_;
 
   // The dummy page that anchors the double linked list of pages.
   Page anchor_;
 
   // The space's free list.
@@ skipping 73 matching lines @@
 
 class NewSpacePage : public MemoryChunk {
  public:
   // GC related flags copied from from-space to to-space when
   // flipping semispaces.
   static const intptr_t kCopyOnFlipFlagsMask =
     (1 << MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING) |
     (1 << MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING) |
     (1 << MemoryChunk::SCAN_ON_SCAVENGE);
 
+  static const int kAreaSize = Page::kNonCodeObjectAreaSize;
+
   inline NewSpacePage* next_page() const {
     return static_cast<NewSpacePage*>(next_chunk());
   }
 
   inline void set_next_page(NewSpacePage* page) {
     set_next_chunk(page);
   }
 
   inline NewSpacePage* prev_page() const {
     return static_cast<NewSpacePage*>(prev_chunk());
@@ skipping 92 matching lines @@
   bool GrowTo(int new_capacity);
 
   // Shrinks the semispace to the new capacity.  The new capacity
   // requested must be more than the amount of used memory in the
   // semispace and less than the current capacity.
   bool ShrinkTo(int new_capacity);
 
   // Returns the start address of the first page of the space.
   Address space_start() {
     ASSERT(anchor_.next_page() != &anchor_);
-    return anchor_.next_page()->body();
+    return anchor_.next_page()->area_start();
   }
 
   // Returns the start address of the current page of the space.
   Address page_low() {
-    return current_page_->body();
+    return current_page_->area_start();
   }
 
   // Returns one past the end address of the space.
   Address space_end() {
-    return anchor_.prev_page()->body_limit();
+    return anchor_.prev_page()->area_end();
   }
 
   // Returns one past the end address of the current page of the space.
   Address page_high() {
-    return current_page_->body_limit();
+    return current_page_->area_end();
   }
 
   bool AdvancePage() {
     NewSpacePage* next_page = current_page_->next_page();
     if (next_page == anchor()) return false;
     current_page_ = next_page;
     return true;
   }
 
   // Resets the space to using the first page.
@@ skipping 115 matching lines @@
   SemiSpaceIterator(NewSpace* space, Address start);
   // Iterate from one address to another in the same semi-space.
   SemiSpaceIterator(Address from, Address to);
 
   HeapObject* Next() {
     if (current_ == limit_) return NULL;
     if (NewSpacePage::IsAtEnd(current_)) {
       NewSpacePage* page = NewSpacePage::FromLimit(current_);
       page = page->next_page();
       ASSERT(!page->is_anchor());
-      current_ = page->body();
+      current_ = page->area_start();
       if (current_ == limit_) return NULL;
     }
 
     HeapObject* object = HeapObject::FromAddress(current_);
     int size = (size_func_ == NULL) ? object->Size() : size_func_(object);
 
     current_ += size;
     return object;
   }
 
@@ skipping 87 matching lines @@
         == reinterpret_cast<uintptr_t>(start_);
   }
 
   bool Contains(Object* o) {
     Address a = reinterpret_cast<Address>(o);
     return (reinterpret_cast<uintptr_t>(a) & object_mask_) == object_expected_;
   }
 
   // Return the allocated bytes in the active semispace.
   virtual intptr_t Size() {
-    return pages_used_ * Page::kObjectAreaSize +
+    return pages_used_ * NewSpacePage::kAreaSize +
         static_cast<int>(top() - to_space_.page_low());
   }
 
   // The same, but returning an int.  We have to have the one that returns
   // intptr_t because it is inherited, but if we know we are dealing with the
   // new space, which can't get as big as the other spaces then this is useful:
   int SizeAsInt() { return static_cast<int>(Size()); }
 
   // Return the current capacity of a semispace.
   intptr_t EffectiveCapacity() {
     SLOW_ASSERT(to_space_.Capacity() == from_space_.Capacity());
-    return (to_space_.Capacity() / Page::kPageSize) * Page::kObjectAreaSize;
+    return (to_space_.Capacity() / Page::kPageSize) * NewSpacePage::kAreaSize;
   }
 
   // Return the current capacity of a semispace.
   intptr_t Capacity() {
     ASSERT(to_space_.Capacity() == from_space_.Capacity());
     return to_space_.Capacity();
   }
 
   // Return the total amount of memory committed for new space.
   intptr_t CommittedMemory() {
@@ skipping 196 matching lines @@
   OldSpace(Heap* heap,
            intptr_t max_capacity,
            AllocationSpace id,
            Executability executable)
       : PagedSpace(heap, max_capacity, id, executable) {
     page_extra_ = 0;
   }
 
   // The limit of allocation for a page in this space.
   virtual Address PageAllocationLimit(Page* page) {
-    return page->ObjectAreaEnd();
+    return page->area_end();
   }
 
  public:
   TRACK_MEMORY("OldSpace")
 };
 
 
 // For contiguous spaces, top should be in the space (or at the end) and limit
 // should be the end of the space.
 #define ASSERT_SEMISPACE_ALLOCATION_INFO(info, space) \
   SLOW_ASSERT((space).page_low() <= (info).top             \
               && (info).top <= (space).page_high()         \
               && (info).limit <= (space).page_high())
 
 
 // -----------------------------------------------------------------------------
 // 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,
              const char* name)
       : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE),
         object_size_in_bytes_(object_size_in_bytes),
         name_(name) {
-    page_extra_ = Page::kObjectAreaSize % 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->ObjectAreaEnd() - page_extra_;
+    return page->area_end() - page_extra_;
   }
 
   int object_size_in_bytes() { return object_size_in_bytes_; }
 
   // Prepares for a mark-compact GC.
   virtual void PrepareForMarkCompact();
 
  protected:
   void ResetFreeList() {
     free_list_.Reset();
@@ skipping 33 matching lines @@
       return (size / Map::kSize) * Map::kSize;
     }
   }
 
  protected:
 #ifdef DEBUG
   virtual void VerifyObject(HeapObject* obj);
 #endif
 
  private:
-  static const int kMapsPerPage = Page::kObjectAreaSize / Map::kSize;
+  static const int kMapsPerPage = Page::kNonCodeObjectAreaSize / Map::kSize;
 
   // Do map space compaction if there is a page gap.
   int CompactionThreshold() {
     return kMapsPerPage * (max_map_space_pages_ - 1);
   }
 
   const int max_map_space_pages_;
 
  public:
   TRACK_MEMORY("MapSpace")
@@ skipping 210 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_