Unify markbits for old and new spaces.

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 146 matching lines @@
   CellType mask_;
   // This boolean indicates that the object is in a data-only space with no
   // pointers.  This enables some optimizations when marking.
   // It is expected that this field is inlined and turned into control flow
   // at the place where the MarkBit object is created.
   bool data_only_;
 };
 
 
 // Bitmap is a sequence of cells each containing fixed number of bits.
-template<typename StorageDescriptor>
 class Bitmap {
  public:
   static const uint32_t kBitsPerCell = 32;
   static const uint32_t kBitsPerCellLog2 = 5;
   static const uint32_t kBitIndexMask = kBitsPerCell - 1;
 
+  static const size_t kLength =
+    (1 << kPageSizeBits) >> (kPointerSizeLog2);
+
+  static const size_t kSize =
+    (1 << kPageSizeBits) >> (kPointerSizeLog2 + kBitsPerByteLog2);
+
+
   static int CellsForLength(int length) {
     return (length + kBitsPerCell - 1) >> kBitsPerCellLog2;
   }
 
   int CellsCount() {
-    return StorageDescriptor::CellsCount(this->address());
+    return CellsForLength(kLength);
   }
 
   static int SizeFor(int cells_count) {
     return sizeof(MarkBit::CellType)*cells_count;
   }
 
   INLINE(static uint32_t IndexToCell(uint32_t index)) {
     return index >> kBitsPerCellLog2;
   }
 
@@ skipping 198 matching lines @@
     flags_ = chunk->flags_;
   }
 
   static const intptr_t kAlignment = (1 << kPageSizeBits);
 
   static const intptr_t kAlignmentMask = kAlignment - 1;
 
   static const size_t kHeaderSize = kPointerSize + kPointerSize + kPointerSize +
     kPointerSize + kPointerSize + kPointerSize + kPointerSize + kPointerSize;
 
-  static const size_t kMarksBitmapLength =
-    (1 << kPageSizeBits) >> (kPointerSizeLog2);
-
-  static const size_t kMarksBitmapSize =
-    (1 << kPageSizeBits) >> (kPointerSizeLog2 + kBitsPerByteLog2);
-
   static const int kBodyOffset =
-    CODE_POINTER_ALIGN(MAP_POINTER_ALIGN(kHeaderSize + kMarksBitmapSize));
+    CODE_POINTER_ALIGN(MAP_POINTER_ALIGN(kHeaderSize + Bitmap::kSize));
 
   // The start offset of the object area in a page. Aligned to both maps and
   // code alignment to be suitable for both.  Also aligned to 32 words because
   // the marking bitmap is arranged in 32 bit chunks.
   static const int kObjectStartAlignment = 32 * kPointerSize;
   static const int kObjectStartOffset = kBodyOffset - 1 +
       (kObjectStartAlignment - (kBodyOffset - 1) % kObjectStartAlignment);
 
   size_t size() const { return size_; }
 
   Executability executable() {
     return IsFlagSet(IS_EXECUTABLE) ? EXECUTABLE : NOT_EXECUTABLE;
   }
 
   bool ContainsOnlyData() {
     return IsFlagSet(CONTAINS_ONLY_DATA);
   }
 
   // ---------------------------------------------------------------------
   // Markbits support
 
-  class BitmapStorageDescriptor {
-   public:
-    INLINE(static int CellsCount(Address addr)) {
-      return Bitmap<BitmapStorageDescriptor>::CellsForLength(
-          kMarksBitmapLength);
-    }
-  };
-
-  typedef Bitmap<BitmapStorageDescriptor> MarkbitsBitmap;
-
-  inline MarkbitsBitmap* markbits() {
-    return MarkbitsBitmap::FromAddress(address() + kHeaderSize);
+  inline Bitmap* markbits() {
+    return Bitmap::FromAddress(address() + kHeaderSize);
   }
 
   void PrintMarkbits() { markbits()->Print(); }
 
   inline uint32_t AddressToMarkbitIndex(Address addr) {
     return static_cast<uint32_t>(addr - this->address()) >> kPointerSizeLog2;
   }
 
   inline static uint32_t FastAddressToMarkbitIndex(Address addr) {
     const intptr_t offset =
@@ skipping 102 matching lines @@
   // 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) >> MarkbitsBitmap::kBitsPerCellLog2;
+    (kObjectStartOffset/kPointerSize) >> Bitmap::kBitsPerCellLog2;
 
   static const int kLastUsedCell =
     ((kPageSize - kPointerSize)/kPointerSize) >>
-      MarkbitsBitmap::kBitsPerCellLog2;
+      Bitmap::kBitsPerCellLog2;
 
   inline void ClearGCFields();
 
   static inline Page* Initialize(Heap* heap,
                                  MemoryChunk* chunk,
                                  Executability executable,
                                  PagedSpace* owner);
 
   void InitializeAsAnchor(PagedSpace* owner);
 
@@ skipping 1287 matching lines @@
   }
 
   inline intptr_t inline_alloction_limit_step() {
     return inline_alloction_limit_step_;
   }
 
   NewSpacePage* ActivePage() {
     return to_space_.current_page();
   }
 
+  NewSpacePage* InactivePage() {
+    return from_space_.current_page();
+  }
+
  private:
   Address chunk_base_;
   uintptr_t chunk_size_;
 
   // The semispaces.
   SemiSpace to_space_;
   SemiSpace from_space_;
 
   // Start address and bit mask for containment testing.
   Address start_;
@@ skipping 376 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_