VERIFY_PREDICTABLE build mode introduced. Shadow pages support added.

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 "allocation.h"
 #include "hashmap.h"
 #include "list.h"
@@ skipping 288 matching lines @@
   }
 
   void set_next_chunk(MemoryChunk* next) {
     Release_Store(&next_chunk_, reinterpret_cast<AtomicWord>(next));
   }
 
   void set_prev_chunk(MemoryChunk* prev) {
     Release_Store(&prev_chunk_, reinterpret_cast<AtomicWord>(prev));
   }
 
+  uintptr_t shadow_data_offset() { return shadow_data_offset_; }
+
+  MemoryChunk* shadow_chunk() { return shadow_chunk_; }
+  void set_shadow_chunk(MemoryChunk* shadow) { shadow_chunk_ = shadow; }
+
   Space* owner() const {
     if ((reinterpret_cast<intptr_t>(owner_) & kFailureTagMask) ==
         kFailureTag) {
       return reinterpret_cast<Space*>(reinterpret_cast<intptr_t>(owner_) -
                                       kFailureTag);
     } else {
       return NULL;
     }
   }
 
@@ skipping 221 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 = 0;
 
   static const intptr_t kLiveBytesOffset =
      kSizeOffset + kPointerSize + kPointerSize + kPointerSize +
      kPointerSize + kPointerSize +
+     kPointerSize + kPointerSize + kPointerSize +
      kPointerSize + kPointerSize + kPointerSize + kIntSize;
 
   static const size_t kSlotsBufferOffset = kLiveBytesOffset + kIntSize;
 
   static const size_t kWriteBarrierCounterOffset =
       kSlotsBufferOffset + kPointerSize + kPointerSize;
 
   static const size_t kHeaderSize = kWriteBarrierCounterOffset + kPointerSize +
                                     kIntSize + kIntSize + kPointerSize +
                                     5 * kPointerSize +
@@ skipping 118 matching lines @@
   static inline void UpdateHighWaterMark(Address mark);
 
  protected:
   size_t size_;
   intptr_t flags_;
 
   // Start and end of allocatable memory on this chunk.
   Address area_start_;
   Address area_end_;
 
+  MemoryChunk* shadow_chunk_;
+  // Offset to object's shadow data.
+  intptr_t shadow_data_offset_;
+  // Shadow data storage for large objects.
+  intptr_t large_object_shadow_data_;
+
   // 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_;
@@ skipping 405 matching lines @@
 #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,
                              Space* space);
 
+  // Allocates shadow page of respective size and sets it as a shadow
+  // of given chunk.
+  bool AllocateShadowChunkFor(MemoryChunk* chunk);
+
+  // Frees and clears shadow page of given chunk.
+  void FreeShadowChunkFor(MemoryChunk* chunk);
+
+
   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* controller);
 
   bool CommitMemory(Address addr, size_t size, Executability executable);
@@ skipping 1155 matching lines @@
   size_t CommittedPhysicalMemory();
 
  private:
   // Flips the semispace between being from-space and to-space.
   // Copies the flags into the masked positions on all pages in the space.
   void FlipPages(intptr_t flags, intptr_t flag_mask);
 
   // Updates Capacity and MaximumCommitted based on new capacity.
   void SetCapacity(int new_capacity);
 
+  // Allocates new shadow chunk for pages with indexes in the range
+  // [start_index, end_index).
+  // Returns false on allocation failure.
+  bool AllocateShadowChunksForPages(int start_index, int end_index);
+
+  // Frees shadow chunk for pages with indexes in the range
+  // [start_index, end_index).
+  void FreeShadowChunksForPages(int start_index, int end_index);
+
   NewSpacePage* anchor() { return &anchor_; }
 
   // The current and maximum capacity of the space.
   int capacity_;
   int maximum_capacity_;
   int initial_capacity_;
 
   intptr_t maximum_committed_;
 
   // The start address of the space.
@@ skipping 698 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_