[heap] Fix mark bits for partially compacted pages.

src/heap/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_HEAP_SPACES_H_
 #define V8_HEAP_SPACES_H_
 
 #include "src/allocation.h"
 #include "src/atomic-utils.h"
 #include "src/base/atomicops.h"
@@ skipping 147 matching lines @@
   int CellsCount() { 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;
   }
 
+  V8_INLINE static uint32_t IndexInCell(uint32_t index) {
+    return index & kBitIndexMask;
+  }
+
   INLINE(static uint32_t CellToIndex(uint32_t index)) {
     return index << kBitsPerCellLog2;
   }
 
   INLINE(static uint32_t CellAlignIndex(uint32_t index)) {
     return (index + kBitIndexMask) & ~kBitIndexMask;
   }
 
   INLINE(MarkBit::CellType* cells()) {
     return reinterpret_cast<MarkBit::CellType*>(this);
   }
 
   INLINE(Address address()) { return reinterpret_cast<Address>(this); }
 
   INLINE(static Bitmap* FromAddress(Address addr)) {
     return reinterpret_cast<Bitmap*>(addr);
   }
 
   inline MarkBit MarkBitFromIndex(uint32_t index) {
-    MarkBit::CellType mask = 1 << (index & kBitIndexMask);
+    MarkBit::CellType mask = 1u << IndexInCell(index);
     MarkBit::CellType* cell = this->cells() + (index >> kBitsPerCellLog2);
     return MarkBit(cell, mask);
   }
 
   static inline void Clear(MemoryChunk* chunk);
 
   static void PrintWord(uint32_t word, uint32_t himask = 0) {
     for (uint32_t mask = 1; mask != 0; mask <<= 1) {
       if ((mask & himask) != 0) PrintF("[");
       PrintF((mask & word) ? "1" : "0");
@@ skipping 51 matching lines @@
   }
 
   bool IsClean() {
     for (int i = 0; i < CellsCount(); i++) {
       if (cells()[i] != 0) {
         return false;
       }
     }
     return true;
   }
+
+  // Clears all bits starting from {cell_base_index} up to and excluding
+  // {index}. Note that the start will be cell aligned, while the end can
+  // be any index following {cell_base_index}.
+  void ClearTillIndex(uint32_t cell_base_index, uint32_t index) {

[ulan, 2015/10/08 12:43:14]

Let's assert that cell_base_index is aligned.

[Michael Lippautz, 2015/10/08 12:57:51]

Done.

+    DCHECK_GE(index, cell_base_index);
+    uint32_t start_cell_index = IndexToCell(cell_base_index);
+    uint32_t end_cell_index = IndexToCell(index);
+    DCHECK_GE(end_cell_index, start_cell_index);
+    // Clear all cells till the cell containing the last index.
+    for (uint32_t i = start_cell_index; i < end_cell_index; i++) {
+      cells()[i] = 0;
+    }
+    // Clear all bits in the last cell till the last bit before index.
+    uint32_t clear_mask = ~((1u << IndexInCell(index)) - 1);
+    cells()[end_cell_index] &= clear_mask;
+  }
 };
 
 
 class SkipList;
 class SlotsBuffer;
 
 // MemoryChunk represents a memory region owned by a specific space.
 // It is divided into the header and the body. Chunk start is always
 // 1MB aligned. Start of the body is aligned so it can accommodate
 // any heap object.
@@ skipping 2724 matching lines @@
     count = 0;
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_H_