Get rid of distinction between below- and above-watermark in page allocation....

src/mark-compact.h

-// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// 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
 //       with the distribution.
@@ skipping 100 matching lines @@
   // the given page.
   INLINE(static Address FirstMarkedObject(Page* page,
                                           uint32_t cell_index,
                                           uint32_t cell)) {
     ASSERT(cell != 0);
     uint32_t bit = CompilerIntrinsics::CountTrailingZeros(cell);
     return page->MarkbitIndexToAddress(
         Page::MarkbitsBitmap::CellToIndex(cell_index) + bit);
   }
 
-  INLINE(static Address FirstLiveObject(Address start,
-                                        Address limit)) {
-    ASSERT(!Heap::InNewSpace(start));
-    if (start >= limit) return start;
-
-    Page* page = Page::FromAddress(start);
-
-    // If start is above linearity boundary is continuous then
-    // it coincides with a start of the live object. Just
-    // return it.
-    if (start >= page->linearity_boundary()) return start;
-
-    Page::MarkbitsBitmap* bitmap = page->markbits();
-    uint32_t markbit = page->AddressToMarkbitIndex(start);
-
-    // If the start address is marked return it.
-    if (bitmap->Get(markbit)) return start;
-
-    uint32_t* cells = bitmap->cells();
-    uint32_t cell_index = Page::MarkbitsBitmap::IndexToCell(markbit);
-
-    // Round limit towards start of the next cell.
-    uint32_t last_cell_index =
-        Page::MarkbitsBitmap::IndexToCell(
-            Page::MarkbitsBitmap::CellAlignIndex(
-                page->AddressToMarkbitIndex(limit)));
-
-    ASSERT(cell_index < last_cell_index);
-
-    while (cell_index < last_cell_index && cells[cell_index] == 0) cell_index++;
-
-    if (cell_index == last_cell_index) return limit;
-
-    return FirstMarkedObject(page, cell_index, cells[cell_index]);
-  }
-
-  INLINE(static Address NextLiveObject(HeapObject* obj,
-                                       int size,
-                                       Address end)) {
-    ASSERT(!Heap::InNewSpace(obj));
-    Page* page = Page::FromAddress(obj->address());
-    Address watermark = page->linearity_boundary();
-    Address next_addr = obj->address() + size;
-
-    if (next_addr >= watermark) return next_addr;
-
-    Page::MarkbitsBitmap* bitmap = page->markbits();
-    uint32_t markbit = page->AddressToMarkbitIndex(next_addr);
-
-    if (bitmap->Get(markbit)) return next_addr;
-
-    uint32_t* cells = bitmap->cells();
-    uint32_t cell_index = Page::MarkbitsBitmap::IndexToCell(markbit);
-
-    ASSERT(IsMarked(obj));
-
-    uint32_t bit  = Page::MarkbitsBitmap::IndexToBit(markbit);
-    uint32_t mask = (~1) << bit;
-    if ((cells[cell_index] & mask) != 0) {
-      // There are more marked objects in this cell.
-      return FirstMarkedObject(page, cell_index, cells[cell_index] & mask);
-    }
-
-    Address limit = Min(watermark, end);
-
-    // Round limit towards start of the next cell.
-    uint32_t last_cell_index =
-      Page::MarkbitsBitmap::IndexToCell(
-          Page::MarkbitsBitmap::CellAlignIndex(
-              page->AddressToMarkbitIndex(limit)));
-
-    // We expect last_cell to be bigger than cell because
-    // we rounded limit towards start of the next cell
-    // and limit is bigger than address of the current.
-    ASSERT(cell_index < last_cell_index);
-
-    // We skip current cell because it contains no unvisited
-    // live objects.
-    do {
-      cell_index++;
-    } while (cell_index < last_cell_index && cells[cell_index] == 0);
-
-    // If we reached last_cell return limit
-    // not the start of the last_cell because
-    // limit can be in the middle of the previous cell.
-    if (cell_index == last_cell_index) return limit;
-
-    return FirstMarkedObject(page, cell_index, cells[cell_index]);
-  }
-
   static void TransferMark(Address old_start, Address new_start);
 
   static bool Setup();
 
   static void TearDown();
 
  private:
   class BitmapStorageDescriptor {
    public:
     INLINE(static int CellsCount(Address addr)) {
@@ skipping 66 matching lines @@
   typedef void (*EncodingFunction)(HeapObject* old_object,
                                    int object_size,
                                    Object* new_object,
                                    int* offset);
 
   // Type of functions to process non-live objects.
   typedef void (*ProcessNonLiveFunction)(HeapObject* object);
 
   // Set the global force_compaction flag, it must be called before Prepare
   // to take effect.
-  static void SetForceCompaction(bool value) {
-    force_compaction_ = value;
+  static void SetFlags(int flags) {
+    force_compaction_ = ((flags & Heap::kForceCompactionMask) != 0);
+    sweep_precisely_ = ((flags & Heap::kMakeHeapIterableMask) != 0);
   }
 
 
   static void Initialize();
 
   // Prepares for GC by resetting relocation info in old and map spaces and
   // choosing spaces to compact.
   static void Prepare(GCTracer* tracer);
 
   // Performs a global garbage collection.
@@ skipping 43 matching lines @@
     RELOCATE_OBJECTS
   };
 
   // The current stage of the collector.
   static CollectorState state_;
 #endif
 
   // Global flag that forces a compaction.
   static bool force_compaction_;
 
+  // Global flag that forces sweeping to be precise, so we can traverse the
+  // heap.
+  static bool sweep_precisely_;
+
   // Global flag indicating whether spaces were compacted on the last GC.
   static bool compacting_collection_;
 
   // Global flag indicating whether spaces will be compacted on the next GC.
   static bool compact_on_next_gc_;
 
   // A pointer to the current stack-allocated GC tracer object during a full
   // collection (NULL before and after).
   static GCTracer* tracer_;
 
@@ skipping 169 matching lines @@
 
   friend class UnmarkObjectVisitor;
   static void UnmarkObject(HeapObject* obj);
 #endif
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_